🧠 Local LLM + RAG + CRUD

from langchain.tools import Tool
from langchain.agents import initialize_agent, AgentType
import os
import json

# CRUD Tools definieren
class FileSystemTools:
    
    @staticmethod
    def create_file(filename: str, content: str = "") -> str:
        """Erstellt eine neue Datei"""
        try:
            with open(f"./user_files/{filename}", 'w') as f:
                f.write(content)
            return f"✓ Datei {filename} erstellt"
        except Exception as e:
            return f"✗ Fehler: {str(e)}"
    
    @staticmethod
    def read_file(filename: str) -> str:
        """Liest eine Datei"""
        try:
            with open(f"./user_files/{filename}", 'r') as f:
                return f.read()
        except Exception as e:
            return f"✗ Fehler: {str(e)}"
    
    @staticmethod
    def update_file(filename: str, content: str) -> str:
        """Aktualisiert eine Datei"""
        try:
            with open(f"./user_files/{filename}", 'w') as f:
                f.write(content)
            return f"✓ Datei {filename} aktualisiert"
        except Exception as e:
            return f"✗ Fehler: {str(e)}"
    
    @staticmethod
    def delete_file(filename: str) -> str:
        """Löscht eine Datei"""
        try:
            os.remove(f"./user_files/{filename}")
            return f"✓ Datei {filename} gelöscht"
        except Exception as e:
            return f"✗ Fehler: {str(e)}"
    
    @staticmethod
    def list_files(directory: str = "./user_files") -> str:
        """Listet alle Dateien auf"""
        try:
            files = os.listdir(directory)
            return json.dumps(files, indent=2)
        except Exception as e:
            return f"✗ Fehler: {str(e)}"
    
    @staticmethod
    def search_files(query: str) -> str:
        """Durchsucht Dateien nach Inhalt"""
        results = []
        for filename in os.listdir("./user_files"):
            try:
                with open(f"./user_files/{filename}", 'r') as f:
                    content = f.read()
                    if query.lower() in content.lower():
                        results.append(filename)
            except:
                continue
        return json.dumps(results, indent=2)

from langchain.agents import initialize_agent, Tool, AgentType

# Tools definieren
tools = [
    Tool(
        name="CreateFile",
        func=FileSystemTools.create_file,
        description="Erstellt eine neue Datei. Input: filename, content"
    ),
    Tool(
        name="ReadFile",
        func=FileSystemTools.read_file,
        description="Liest den Inhalt einer Datei. Input: filename"
    ),
    Tool(
        name="UpdateFile",
        func=FileSystemTools.update_file,
        description="Aktualisiert eine bestehende Datei. Input: filename, content"
    ),
    Tool(
        name="DeleteFile",
        func=FileSystemTools.delete_file,
        description="Löscht eine Datei. Input: filename"
    ),
    Tool(
        name="ListFiles",
        func=FileSystemTools.list_files,
        description="Listet alle Dateien auf"
    ),
    Tool(
        name="SearchFiles",
        func=FileSystemTools.search_files,
        description="Durchsucht Dateien nach Text. Input: query"
    )
]

# Agent initialisieren
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True
)

# Agent verwenden
response = agent.run("Erstelle eine Datei todo.txt mit Inhalt 'Projekt fertigstellen'")
print(response)

class SystemTools:
    """Erweiterte OS-Operationen"""
    
    @staticmethod
    def execute_shell(command: str) -> str:
        """Führt Shell-Befehle aus (SICHER!)"""
        # Whitelist von erlaubten Befehlen
        allowed = ['ls', 'pwd', 'date', 'whoami']
        cmd = command.split()[0]
        
        if cmd not in allowed:
            return f"✗ Befehl '{cmd}' nicht erlaubt"
        
        import subprocess
        try:
            result = subprocess.run(
                command, 
                shell=True, 
                capture_output=True, 
                text=True,
                timeout=5
            )
            return result.stdout
        except Exception as e:
            return f"✗ Fehler: {str(e)}"
    
    @staticmethod
    def get_system_info() -> str:
        """Gibt System-Informationen zurück"""
        import platform
        info = {
            'os': platform.system(),
            'version': platform.version(),
            'architecture': platform.machine(),
            'processor': platform.processor()
        }
        return json.dumps(info, indent=2)
    
    @staticmethod
    def open_app(app_name: str) -> str:
        """Öffnet eine App"""
        # Hier würdest du deine App-Launcher-Logik einbauen
        return f"✓ App '{app_name}' geöffnet"
    
    @staticmethod
    def close_app(app_name: str) -> str:
        """Schließt eine App"""
        return f"✓ App '{app_name}' geschlossen"

# Als Tools registrieren
system_tools = [
    Tool(
        name="ExecuteShell",
        func=SystemTools.execute_shell,
        description="Führt Shell-Befehle aus (nur sichere Befehle)"
    ),
    Tool(
        name="GetSystemInfo",
        func=SystemTools.get_system_info,
        description="Gibt System-Informationen zurück"
    ),
    Tool(
        name="OpenApp",
        func=SystemTools.open_app,
        description="Öffnet eine Anwendung. Input: app_name"
    ),
    Tool(
        name="CloseApp",
        func=SystemTools.close_app,
        description="Schließt eine Anwendung. Input: app_name"
    )
]